home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / ppc-amigaos / include / powerup / ppcpragmas / mathieeesingtrans_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-02-28  |  9KB  |  337 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_MATHIEEESINGTRANS_H
  4. #define _PPCPRAGMA_MATHIEEESINGTRANS_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__MATHIEEESINGTRANS_H
  7. #include <powerup/ppcinline/mathieeesingtrans.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef MATHIEEESINGTRANS_BASE_NAME
  24. #define MATHIEEESINGTRANS_BASE_NAME MathIeeeSingTransBase
  25. #endif /* !MATHIEEESINGTRANS_BASE_NAME */
  26.  
  27. #define    IEEESPAcos(parm)    _IEEESPAcos(MATHIEEESINGTRANS_BASE_NAME, parm)
  28.  
  29. static __inline FLOAT
  30. _IEEESPAcos(void *MathIeeeSingTransBase, FLOAT parm)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.d0        =(ULONG) parm;
  40.     MyCaos.caos_Un.Offset    =    (-120);
  41.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  42.     return((FLOAT)PPCCallOS(&MyCaos));
  43. }
  44.  
  45. #define    IEEESPAsin(parm)    _IEEESPAsin(MATHIEEESINGTRANS_BASE_NAME, parm)
  46.  
  47. static __inline FLOAT
  48. _IEEESPAsin(void *MathIeeeSingTransBase, FLOAT parm)
  49. {
  50. struct Caos    MyCaos;
  51.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  52. //    MyCaos.M68kStart    =    NULL;
  53. //    MyCaos.M68kSize        =    0;
  54.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  55. //    MyCaos.PPCStart        =    NULL;
  56. //    MyCaos.PPCSize        =    0;
  57.     MyCaos.d0        =(ULONG) parm;
  58.     MyCaos.caos_Un.Offset    =    (-114);
  59.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  60.     return((FLOAT)PPCCallOS(&MyCaos));
  61. }
  62.  
  63. #define    IEEESPAtan(parm)    _IEEESPAtan(MATHIEEESINGTRANS_BASE_NAME, parm)
  64.  
  65. static __inline FLOAT
  66. _IEEESPAtan(void *MathIeeeSingTransBase, FLOAT parm)
  67. {
  68. struct Caos    MyCaos;
  69.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  70. //    MyCaos.M68kStart    =    NULL;
  71. //    MyCaos.M68kSize        =    0;
  72.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  73. //    MyCaos.PPCStart        =    NULL;
  74. //    MyCaos.PPCSize        =    0;
  75.     MyCaos.d0        =(ULONG) parm;
  76.     MyCaos.caos_Un.Offset    =    (-30);
  77.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  78.     return((FLOAT)PPCCallOS(&MyCaos));
  79. }
  80.  
  81. #define    IEEESPCos(parm)    _IEEESPCos(MATHIEEESINGTRANS_BASE_NAME, parm)
  82.  
  83. static __inline FLOAT
  84. _IEEESPCos(void *MathIeeeSingTransBase, FLOAT parm)
  85. {
  86. struct Caos    MyCaos;
  87.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  88. //    MyCaos.M68kStart    =    NULL;
  89. //    MyCaos.M68kSize        =    0;
  90.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  91. //    MyCaos.PPCStart        =    NULL;
  92. //    MyCaos.PPCSize        =    0;
  93.     MyCaos.d0        =(ULONG) parm;
  94.     MyCaos.caos_Un.Offset    =    (-42);
  95.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  96.     return((FLOAT)PPCCallOS(&MyCaos));
  97. }
  98.  
  99. #define    IEEESPCosh(parm)    _IEEESPCosh(MATHIEEESINGTRANS_BASE_NAME, parm)
  100.  
  101. static __inline FLOAT
  102. _IEEESPCosh(void *MathIeeeSingTransBase, FLOAT parm)
  103. {
  104. struct Caos    MyCaos;
  105.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  106. //    MyCaos.M68kStart    =    NULL;
  107. //    MyCaos.M68kSize        =    0;
  108.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  109. //    MyCaos.PPCStart        =    NULL;
  110. //    MyCaos.PPCSize        =    0;
  111.     MyCaos.d0        =(ULONG) parm;
  112.     MyCaos.caos_Un.Offset    =    (-66);
  113.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  114.     return((FLOAT)PPCCallOS(&MyCaos));
  115. }
  116.  
  117. #define    IEEESPExp(parm)    _IEEESPExp(MATHIEEESINGTRANS_BASE_NAME, parm)
  118.  
  119. static __inline FLOAT
  120. _IEEESPExp(void *MathIeeeSingTransBase, FLOAT parm)
  121. {
  122. struct Caos    MyCaos;
  123.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  124. //    MyCaos.M68kStart    =    NULL;
  125. //    MyCaos.M68kSize        =    0;
  126.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  127. //    MyCaos.PPCStart        =    NULL;
  128. //    MyCaos.PPCSize        =    0;
  129.     MyCaos.d0        =(ULONG) parm;
  130.     MyCaos.caos_Un.Offset    =    (-78);
  131.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  132.     return((FLOAT)PPCCallOS(&MyCaos));
  133. }
  134.  
  135. #define    IEEESPFieee(parm)    _IEEESPFieee(MATHIEEESINGTRANS_BASE_NAME, parm)
  136.  
  137. static __inline FLOAT
  138. _IEEESPFieee(void *MathIeeeSingTransBase, FLOAT parm)
  139. {
  140. struct Caos    MyCaos;
  141.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  142. //    MyCaos.M68kStart    =    NULL;
  143. //    MyCaos.M68kSize        =    0;
  144.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  145. //    MyCaos.PPCStart        =    NULL;
  146. //    MyCaos.PPCSize        =    0;
  147.     MyCaos.d0        =(ULONG) parm;
  148.     MyCaos.caos_Un.Offset    =    (-108);
  149.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  150.     return((FLOAT)PPCCallOS(&MyCaos));
  151. }
  152.  
  153. #define    IEEESPLog(parm)    _IEEESPLog(MATHIEEESINGTRANS_BASE_NAME, parm)
  154.  
  155. static __inline FLOAT
  156. _IEEESPLog(void *MathIeeeSingTransBase, FLOAT parm)
  157. {
  158. struct Caos    MyCaos;
  159.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  160. //    MyCaos.M68kStart    =    NULL;
  161. //    MyCaos.M68kSize        =    0;
  162.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  163. //    MyCaos.PPCStart        =    NULL;
  164. //    MyCaos.PPCSize        =    0;
  165.     MyCaos.d0        =(ULONG) parm;
  166.     MyCaos.caos_Un.Offset    =    (-84);
  167.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  168.     return((FLOAT)PPCCallOS(&MyCaos));
  169. }
  170.  
  171. #define    IEEESPLog10(parm)    _IEEESPLog10(MATHIEEESINGTRANS_BASE_NAME, parm)
  172.  
  173. static __inline FLOAT
  174. _IEEESPLog10(void *MathIeeeSingTransBase, FLOAT parm)
  175. {
  176. struct Caos    MyCaos;
  177.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  178. //    MyCaos.M68kStart    =    NULL;
  179. //    MyCaos.M68kSize        =    0;
  180.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  181. //    MyCaos.PPCStart        =    NULL;
  182. //    MyCaos.PPCSize        =    0;
  183.     MyCaos.d0        =(ULONG) parm;
  184.     MyCaos.caos_Un.Offset    =    (-126);
  185.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  186.     return((FLOAT)PPCCallOS(&MyCaos));
  187. }
  188.  
  189. #define    IEEESPPow(exp, arg)    _IEEESPPow(MATHIEEESINGTRANS_BASE_NAME, exp, arg)
  190.  
  191. static __inline FLOAT
  192. _IEEESPPow(void *MathIeeeSingTransBase, FLOAT exp, FLOAT arg)
  193. {
  194. struct Caos    MyCaos;
  195.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  196. //    MyCaos.M68kStart    =    NULL;
  197. //    MyCaos.M68kSize        =    0;
  198.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  199. //    MyCaos.PPCStart        =    NULL;
  200. //    MyCaos.PPCSize        =    0;
  201.     MyCaos.d1        =(ULONG) exp;
  202.     MyCaos.d0        =(ULONG) arg;
  203.     MyCaos.caos_Un.Offset    =    (-90);
  204.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  205.     return((FLOAT)PPCCallOS(&MyCaos));
  206. }
  207.  
  208. #define    IEEESPSin(parm)    _IEEESPSin(MATHIEEESINGTRANS_BASE_NAME, parm)
  209.  
  210. static __inline FLOAT
  211. _IEEESPSin(void *MathIeeeSingTransBase, FLOAT parm)
  212. {
  213. struct Caos    MyCaos;
  214.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  215. //    MyCaos.M68kStart    =    NULL;
  216. //    MyCaos.M68kSize        =    0;
  217.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  218. //    MyCaos.PPCStart        =    NULL;
  219. //    MyCaos.PPCSize        =    0;
  220.     MyCaos.d0        =(ULONG) parm;
  221.     MyCaos.caos_Un.Offset    =    (-36);
  222.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  223.     return((FLOAT)PPCCallOS(&MyCaos));
  224. }
  225.  
  226. #define    IEEESPSincos(cosptr, parm)    _IEEESPSincos(MATHIEEESINGTRANS_BASE_NAME, cosptr, parm)
  227.  
  228. static __inline FLOAT
  229. _IEEESPSincos(void *MathIeeeSingTransBase, FLOAT *cosptr, FLOAT parm)
  230. {
  231. struct Caos    MyCaos;
  232.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  233. //    MyCaos.M68kStart    =    NULL;
  234. //    MyCaos.M68kSize        =    0;
  235.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  236. //    MyCaos.PPCStart        =    NULL;
  237. //    MyCaos.PPCSize        =    0;
  238.     MyCaos.a0        =(ULONG) cosptr;
  239.     MyCaos.d0        =(ULONG) parm;
  240.     MyCaos.caos_Un.Offset    =    (-54);
  241.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  242.     return((FLOAT)PPCCallOS(&MyCaos));
  243. }
  244.  
  245. #define    IEEESPSinh(parm)    _IEEESPSinh(MATHIEEESINGTRANS_BASE_NAME, parm)
  246.  
  247. static __inline FLOAT
  248. _IEEESPSinh(void *MathIeeeSingTransBase, FLOAT parm)
  249. {
  250. struct Caos    MyCaos;
  251.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  252. //    MyCaos.M68kStart    =    NULL;
  253. //    MyCaos.M68kSize        =    0;
  254.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  255. //    MyCaos.PPCStart        =    NULL;
  256. //    MyCaos.PPCSize        =    0;
  257.     MyCaos.d0        =(ULONG) parm;
  258.     MyCaos.caos_Un.Offset    =    (-60);
  259.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  260.     return((FLOAT)PPCCallOS(&MyCaos));
  261. }
  262.  
  263. #define    IEEESPSqrt(parm)    _IEEESPSqrt(MATHIEEESINGTRANS_BASE_NAME, parm)
  264.  
  265. static __inline FLOAT
  266. _IEEESPSqrt(void *MathIeeeSingTransBase, FLOAT parm)
  267. {
  268. struct Caos    MyCaos;
  269.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  270. //    MyCaos.M68kStart    =    NULL;
  271. //    MyCaos.M68kSize        =    0;
  272.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  273. //    MyCaos.PPCStart        =    NULL;
  274. //    MyCaos.PPCSize        =    0;
  275.     MyCaos.d0        =(ULONG) parm;
  276.     MyCaos.caos_Un.Offset    =    (-96);
  277.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  278.     return((FLOAT)PPCCallOS(&MyCaos));
  279. }
  280.  
  281. #define    IEEESPTan(parm)    _IEEESPTan(MATHIEEESINGTRANS_BASE_NAME, parm)
  282.  
  283. static __inline FLOAT
  284. _IEEESPTan(void *MathIeeeSingTransBase, FLOAT parm)
  285. {
  286. struct Caos    MyCaos;
  287.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  288. //    MyCaos.M68kStart    =    NULL;
  289. //    MyCaos.M68kSize        =    0;
  290.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  291. //    MyCaos.PPCStart        =    NULL;
  292. //    MyCaos.PPCSize        =    0;
  293.     MyCaos.d0        =(ULONG) parm;
  294.     MyCaos.caos_Un.Offset    =    (-48);
  295.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  296.     return((FLOAT)PPCCallOS(&MyCaos));
  297. }
  298.  
  299. #define    IEEESPTanh(parm)    _IEEESPTanh(MATHIEEESINGTRANS_BASE_NAME, parm)
  300.  
  301. static __inline FLOAT
  302. _IEEESPTanh(void *MathIeeeSingTransBase, FLOAT parm)
  303. {
  304. struct Caos    MyCaos;
  305.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  306. //    MyCaos.M68kStart    =    NULL;
  307. //    MyCaos.M68kSize        =    0;
  308.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  309. //    MyCaos.PPCStart        =    NULL;
  310. //    MyCaos.PPCSize        =    0;
  311.     MyCaos.d0        =(ULONG) parm;
  312.     MyCaos.caos_Un.Offset    =    (-72);
  313.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  314.     return((FLOAT)PPCCallOS(&MyCaos));
  315. }
  316.  
  317. #define    IEEESPTieee(parm)    _IEEESPTieee(MATHIEEESINGTRANS_BASE_NAME, parm)
  318.  
  319. static __inline FLOAT
  320. _IEEESPTieee(void *MathIeeeSingTransBase, FLOAT parm)
  321. {
  322. struct Caos    MyCaos;
  323.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  324. //    MyCaos.M68kStart    =    NULL;
  325. //    MyCaos.M68kSize        =    0;
  326.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  327. //    MyCaos.PPCStart        =    NULL;
  328. //    MyCaos.PPCSize        =    0;
  329.     MyCaos.d0        =(ULONG) parm;
  330.     MyCaos.caos_Un.Offset    =    (-102);
  331.     MyCaos.a6        =(ULONG) MathIeeeSingTransBase;    
  332.     return((FLOAT)PPCCallOS(&MyCaos));
  333. }
  334.  
  335. #endif /* SASC Pragmas */
  336. #endif /* !_PPCPRAGMA_MATHIEEESINGTRANS_H */
  337.